In [1]:
import numpy as np
import pandas as pd
import seaborn as sns
import plotly.graph_objects as go
from plotly.offline import iplot, init_notebook_mode
%pylab inline
In [2]:
df = pd.read_csv('netflix_titles.csv')
df.head()
Out[2]:
EDA¶
DATASET PREPARATION¶
In [3]:
df['date_added'] = pd.to_datetime(df['date_added'])
df['year_added'] = df['date_added'].dt.year
df['month_added'] = df['date_added'].dt.month
df['season_count'] = df.apply(lambda x : x['duration'].split(" ")[0] if "Season" in x['duration'] else "", axis = 1)
df['duration'] = df.apply(lambda x : x['duration'].split(" ")[0] if "Season" not in x['duration'] else "", axis = 1)
df.head()
Out[3]:
In [4]:
df.describe(include='all')
Out[4]:
In [5]:
# Shape of the data.
df.shape
Out[5]:
In [6]:
df.isnull().sum()
Out[6]:
CONTENT TYPE ON NETFLIX¶
In [7]:
col = "type"
grouped = df[col].value_counts().reset_index()
grouped = grouped.rename(columns = {col : "count", "index" : col})
## plot
trace = go.Pie(labels=grouped[col], values=grouped['count'], pull=[0.05, 0], marker=dict(colors=["#6ad49b", "#a678de"]))
layout = go.Layout(title="", height=400, legend=dict(x=0.1, y=1.1))
fig = go.Figure(data = [trace], layout = layout)
iplot(fig)
The above plot shows that 2/3rd of the content on Netflix is movies and remaining 32% of them are TV Shows.
GROWTH IN CINTENT OVER THE YEARS¶
In [8]:
d1 = df[df["type"] == "TV Show"]
d2 = df[df["type"] == "Movie"]
col = "year_added"
vc1 = d1[col].value_counts().reset_index()
vc1 = vc1.rename(columns = {col : "count", "index" : col})
vc1['percent'] = vc1['count'].apply(lambda x : 100*x/sum(vc1['count']))
vc1 = vc1.sort_values(col)
vc2 = d2[col].value_counts().reset_index()
vc2 = vc2.rename(columns = {col : "count", "index" : col})
vc2['percent'] = vc2['count'].apply(lambda x : 100*x/sum(vc2['count']))
vc2 = vc2.sort_values(col)
trace1 = go.Scatter(x=vc1[col], y=vc1["count"], name="TV Shows", marker=dict(color="#a678de"))
trace2 = go.Scatter(x=vc2[col], y=vc2["count"], name="Movies", marker=dict(color="#6ad49b"))
data = [trace1, trace2]
layout = go.Layout(title="Content added over the years", legend=dict(x=0.1, y=1.1, orientation="h"))
fig = go.Figure(data, layout=layout)
fig.show()
The growth in number of movies on netflix is much higher than that od TV shows. About 1300 new movies were added in both 2018 and 2019. The growth in content started from 2013. Netflix kept on adding different movies and tv shows on its platform over the years. This content was of different variety - content from different countries, content which was released over the years.
ORGINIAL RELEASE YEAR OF MOVIES¶
In [9]:
col = "release_year"
vc1 = d1[col].value_counts().reset_index()
vc1 = vc1.rename(columns = {col : "count", "index" : col})
vc1['percent'] = vc1['count'].apply(lambda x : 100*x/sum(vc1['count']))
vc1 = vc1.sort_values(col)
vc2 = d2[col].value_counts().reset_index()
vc2 = vc2.rename(columns = {col : "count", "index" : col})
vc2['percent'] = vc2['count'].apply(lambda x : 100*x/sum(vc2['count']))
vc2 = vc2.sort_values(col)
trace1 = go.Bar(x=vc1[col], y=vc1["count"], name="TV Shows", marker=dict(color="#a678de"))
trace2 = go.Bar(x=vc2[col], y=vc2["count"], name="Movies", marker=dict(color="#6ad49b"))
data = [trace1, trace2]
layout = go.Layout(title="Content added over the years", legend=dict(x=0.1, y=1.1, orientation="h"))
fig = go.Figure(data, layout=layout)
fig.show()
IN WHICH MONTH, THE CONTENT IS ADDED THE MOST¶
In [10]:
col = 'month_added'
vc1 = d1[col].value_counts().reset_index()
vc1 = vc1.rename(columns = {col : "count", "index" : col})
vc1['percent'] = vc1['count'].apply(lambda x : 100*x/sum(vc1['count']))
vc1 = vc1.sort_values(col)
trace1 = go.Bar(x=vc1[col], y=vc1["count"], name="TV Shows", marker=dict(color="#a678de"))
data = [trace1]
layout = go.Layout(title="In which month, the conent is added the most?", legend=dict(x=0.1, y=1.1, orientation="h"))
fig = go.Figure(data, layout=layout)
fig.show()
OLDEST MOVIES ON NETFLIX¶
In [11]:
small = df.sort_values("release_year", ascending = True)
small = small[small['duration'] != ""]
small[['title', "release_year"]][:20]
Out[11]:
OLDEST TV SHOWS ON NETFLIX¶
In [12]:
small = df.sort_values("release_year", ascending = True)
small = small[small['season_count'] != ""]
small[['title', "release_year"]][:20]
Out[12]:
DISTRIBUTION OF MOVIE DURATION¶
In [13]:
import plotly.figure_factory as ff
x1 = d2['duration'].fillna(0.0).astype(float)
fig = ff.create_distplot([x1], ['a'], bin_size=0.7, curve_type='normal', colors=["#6ad49b"])
fig.update_layout(title_text='Distplot with Normal Distribution')
fig.show()
TV SHOWS WITH MANY SEASONS¶
In [14]:
col = 'season_count'
vc1 = d1[col].value_counts().reset_index()
vc1 = vc1.rename(columns = {col : "count", "index" : col})
vc1['percent'] = vc1['count'].apply(lambda x : 100*x/sum(vc1['count']))
vc1 = vc1.sort_values(col)
trace1 = go.Bar(x=vc1[col], y=vc1["count"], name="TV Shows", marker=dict(color="#a678de"))
data = [trace1]
layout = go.Layout(title="Seasons", legend=dict(x=0.1, y=1.1, orientation="h"))
fig = go.Figure(data, layout=layout)
fig.show()
display(df[df['season_count'] == '15'][['title','director', 'cast','country','release_year']])
GREY'S ANATOMY and NCIS have the highest number of seasons on NETFLIX¶
RATINGS OF THE CONTENT¶
In [15]:
col = "rating"
vc1 = d1[col].value_counts().reset_index()
vc1 = vc1.rename(columns = {col : "count", "index" : col})
vc1['percent'] = vc1['count'].apply(lambda x : 100*x/sum(vc1['count']))
vc1 = vc1.sort_values(col)
vc2 = d2[col].value_counts().reset_index()
vc2 = vc2.rename(columns = {col : "count", "index" : col})
vc2['percent'] = vc2['count'].apply(lambda x : 100*x/sum(vc2['count']))
vc2 = vc2.sort_values(col)
trace1 = go.Bar(x=vc1[col], y=vc1["count"], name="TV Shows", marker=dict(color="#a678de"))
trace2 = go.Bar(x=vc2[col], y=vc2["count"], name="Movies", marker=dict(color="#6ad49b"))
data = [trace1, trace2]
layout = go.Layout(title="Content added over the years", legend=dict(x=0.1, y=1.1, orientation="h"))
fig = go.Figure(data, layout=layout)
fig.show()
TOP CATEGORIES¶
In [16]:
from collections import Counter
col = "listed_in"
categories = ", ".join(d2['listed_in']).split(", ")
counter_list = Counter(categories).most_common(50)
labels = [_[0] for _ in counter_list][::-1]
values = [_[1] for _ in counter_list][::-1]
trace1 = go.Bar(y=labels, x=values, orientation="h", name="TV Shows", marker=dict(color="#a678de"))
data = [trace1]
layout = go.Layout(title="Content added over the years", legend=dict(x=0.1, y=1.1, orientation="h"))
fig = go.Figure(data, layout=layout)
fig.show()
TOP ACTORS ON NETFLIX WITH MOST MOVIES¶
In [17]:
def country_trace(country, flag = "movie"):
df["from_us"] = df['country'].fillna("").apply(lambda x : 1 if country.lower() in x.lower() else 0)
small = df[df["from_us"] == 1]
if flag == "movie":
small = small[small["duration"] != ""]
else:
small = small[small["season_count"] != ""]
cast = ", ".join(small['cast'].fillna("")).split(", ")
tags = Counter(cast).most_common(25)
tags = [_ for _ in tags if "" != _[0]]
labels, values = [_[0]+" " for _ in tags], [_[1] for _ in tags]
trace = go.Bar(y=labels[::-1], x=values[::-1], orientation="h", name="", marker=dict(color="#a678de"))
return trace
from plotly.subplots import make_subplots
traces = []
titles = ["United States", "","India","", "United Kingdom", "Canada","", "Spain","", "Japan"]
for title in titles:
if title != "":
traces.append(country_trace(title))
fig = make_subplots(rows=2, cols=5, subplot_titles=titles)
fig.add_trace(traces[0], 1,1)
fig.add_trace(traces[1], 1,3)
fig.add_trace(traces[2], 1,5)
fig.add_trace(traces[3], 2,1)
fig.add_trace(traces[4], 2,3)
fig.add_trace(traces[5], 2,5)
fig.update_layout(height=1200, showlegend=False)
fig.show()
In [18]:
small = df[df["type"] == "Movie"]
small = small[small["country"] == "India"]
col = "director"
categories = ", ".join(small[col].fillna("")).split(", ")
counter_list = Counter(categories).most_common(12)
counter_list = [_ for _ in counter_list if _[0] != ""]
labels = [_[0] for _ in counter_list][::-1]
values = [_[1] for _ in counter_list][::-1]
trace1 = go.Bar(y=labels, x=values, orientation="h", name="TV Shows", marker=dict(color="orange"))
data = [trace1]
layout = go.Layout(title="Movie Directors from India with most content", legend=dict(x=0.1, y=1.1, orientation="h"))
fig = go.Figure(data, layout=layout)
fig.show()
In [19]:
small = df[df["type"] == "Movie"]
small = small[small["country"] == "United States"]
col = "director"
categories = ", ".join(small[col].fillna("")).split(", ")
counter_list = Counter(categories).most_common(12)
counter_list = [_ for _ in counter_list if _[0] != ""]
labels = [_[0] for _ in counter_list][::-1]
values = [_[1] for _ in counter_list][::-1]
trace1 = go.Bar(y=labels, x=values, orientation="h", name="TV Shows", marker=dict(color="orange"))
data = [trace1]
layout = go.Layout(title="Movie Directors from US with most content", legend=dict(x=0.1, y=1.1, orientation="h"))
fig = go.Figure(data, layout=layout)
fig.show()
Standup comedies on Netflix¶
In [20]:
tag = "Stand-Up Comedy"
df["relevant"] = df['listed_in'].fillna("").apply(lambda x : 1 if tag.lower() in x.lower() else 0)
small = df[df["relevant"] == 1]
small[small["country"] == "United States"][["title", "country","release_year"]].head(20)
Out[20]:
In [21]:
tag = "Stand-Up Comedy"
df["relevant"] = df['listed_in'].fillna("").apply(lambda x : 1 if tag.lower() in x.lower() else 0)
small = df[df["relevant"] == 1]
small[small["country"] == "India"][["title", "country","release_year"]].head(10)
Out[21]:
In [ ]:
In [22]:
display(df[df['season_count'] == '15'][['title','director', 'cast','country','release_year']])
COUNTRIES WITH MOST CONTENT¶
In [23]:
temp_df = df['country'].value_counts().reset_index()[:20]
# create trace1
trace1 = go.Bar(
x = temp_df['index'],
y = temp_df['country'],
marker = dict(color = 'rgb(25,20,253)',
line=dict(color='rgb(0,0,0)',width=1.5)))
layout = go.Layout(title = 'TOP 20 COUNTIES WITH MOST CONTENT' , xaxis = dict(title = 'Countries'), yaxis = dict(title = 'Count'))
fig = go.Figure(data = [trace1], layout = layout)
fig.show()
Wordcloud for Genres¶
In [24]:
from collections import Counter
genres=list(df['listed_in'])
gen=[]
for i in genres:
i=list(i.split(','))
for j in i:
gen.append(j.replace(' ',""))
g=Counter(gen)
In [25]:
from wordcloud import WordCloud, STOPWORDS, ImageColorGenerator
text = list(set(gen))
plt.rcParams['figure.figsize'] = (13, 13)
wordcloud = WordCloud(max_font_size=50, max_words=100,background_color="white").generate(str(text))
plt.imshow(wordcloud,interpolation="bilinear")
plt.axis("off")
plt.show()
In [26]:
text = list(set(gen))
wordcloud = WordCloud(max_font_size=50, max_words=100,background_color="black").generate(str(text))
plt.rcParams['figure.figsize'] = (13, 13)
plt.imshow(wordcloud,interpolation="bilinear")
plt.axis("off")
plt.show()
In [27]:
from sklearn.feature_extraction.text import TfidfVectorizer
#Removing stopwords
tfidf = TfidfVectorizer(stop_words='english')
#Replace NaN with an empty string
df['description'] = df['description'].fillna('')
#Construct the required TF-IDF matrix by fitting and transforming the data
tfidf_matrix = tfidf.fit_transform(df['description'])
#Output the shape of tfidf_matrix
tfidf_matrix.shape
Out[27]:
- This means that there are about 16151 words described for the 6234 movies in this dataset.
Using the Cosine similarity since it is independent of the magnitude and is relatively easy and fast to calculate
In [28]:
# Import linear_kernel
from sklearn.metrics.pairwise import linear_kernel
# Compute the cosine similarity matrix
cosine_sim = linear_kernel(tfidf_matrix, tfidf_matrix)
In [29]:
indices = pd.Series(df.index, index = df['title']).drop_duplicates()
In [30]:
def get_recommendations(title, cosine_sim=cosine_sim):
idx = indices[title]
# Get the pairwsie similarity scores of all movies with that movie
sim_scores = list(enumerate(cosine_sim[idx]))
# Sort the movies based on the similarity scores
sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)
# Get the scores of the 10 most similar movies
sim_scores = sim_scores[1:11]
# Get the movie indices
movie_indices = [i[0] for i in sim_scores]
# Return the top 10 most similar movies
return df['title'].iloc[movie_indices]
In [31]:
get_recommendations('Peaky Blinders')
Out[31]:
In [32]:
get_recommendations('Dark')
Out[32]:
In [33]:
# Filling null values
filled_na = df.fillna('')
filled_na.head()
Out[33]:
In [34]:
# Making all the words lower-case
def clean_data(x):
return str.lower(x.replace(" ", ""))
In [35]:
# Features on which the model is to be filtered
features=['title','director','cast','listed_in','description']
filled_na=filled_na[features]
In [36]:
for feature in features:
filled_na[feature] = filled_na[feature].apply(clean_data)
filled_na.head()
Out[36]:
In [37]:
# Creating a Bag of Words model
def create_bow(x):
return x['title']+ ' ' + x['director'] + ' ' + x['cast'] + ' ' +x['listed_in']+' '+ x['description']
filled_na['bow'] = filled_na.apply(create_bow, axis=1)
From here on, the code is basically similar to the upper model except the fact that count vectorizer is used instead of tfidf.
In [38]:
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.metrics.pairwise import cosine_similarity
cv = CountVectorizer(stop_words='english')
cv_matrix = cv.fit_transform(filled_na['bow'])
cosine_sim_2 = cosine_similarity(cv_matrix, cv_matrix)
In [39]:
filled_na = filled_na.reset_index()
indices = pd.Series(filled_na.index, index=filled_na['title'])
In [40]:
def get_recommendations_new(title, cosine_sim = cosine_sim):
title=title.replace(' ','').lower()
idx = indices[title]
# Get the pairwsie similarity scores of all movies with that movie
sim_scores = list(enumerate(cosine_sim[idx]))
# Sort the movies based on the similarity scores
sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)
# Get the scores of the 10 most similar movies
sim_scores = sim_scores[1:11]
# Get the movie indices
movie_indices = [i[0] for i in sim_scores]
# Return the top 10 most similar movies
return df['title'].iloc[movie_indices]
Making Recommendations¶
In [41]:
get_recommendations_new('Ozark', cosine_sim_2)
Out[41]:
In [42]:
get_recommendations_new('You', cosine_sim_2)
Out[42]:
In [43]:
get_recommendations_new('The Irishman', cosine_sim_2)
Out[43]:
In [44]:
get_recommendations_new('Breaking Bad', cosine_sim_2)
Out[44]:
In [45]:
get_recommendations_new('The Departed', cosine_sim_2)
Out[45]:
In [46]:
get_recommendations_new('Blue Valentine', cosine_sim_2)
Out[46]:
In [ ]: